#include "DemiElfe.h"

#include <iomanip>

#include <boost/assign/list_of.hpp>

using namespace std;
using namespace boost::assign;

const unsigned DemiElfe::nbrEnsembles = 1;

const unsigned DemiElfe::nbrCapacites = 3;

const unsigned DemiElfe::ppAlloues = 25;

/**
 * Liste utilisée pour la construction de Ensembles.
 */
const vector< vector< unsigned > > DemiElfe::ensembleRacial =
  list_of< vector< unsigned> > ( list_of(3)(5)(4) );

const unsigned DemiElfe::taille = 9;

/**
 * Contient les capacités, puis les ensembles raciaux, à la fin.
 */
const vector< CapaciteRaciale > DemiElfe::Liste = list_of
  ( CapaciteRaciale( "Faibles besoin de sommeil"        ,  5 ) )
  ( CapaciteRaciale( "Furtivité"                        , 10 ) )
  ( CapaciteRaciale( "Infravision"                      , 10 ) )
  ( CapaciteRaciale( "Portes secrètes"                  ,  5 ) )
  ( CapaciteRaciale( "Résistance aux charmes et sommeil",  5 ) )
  ( CapaciteRaciale( "Résistance à la chaleur"          ,  5 ) )
  ( CapaciteRaciale( "Résistance au froid"              ,  5 ) )
  ( CapaciteRaciale( "Talent pour les arcs"             ,  5 ) )
  ( CapaciteRaciale( "Talent pour les épées"            ,  5 ) )
  ( CapaciteRaciale( "Demi-Elfe standard"               , 20 ) );

/**
 * Contient la liste des ensembles raciaux (ici un seul).
 */
const vector< EnsembleCapacitesRaciales > DemiElfe::Ensembles = list_of
  ( EnsembleCapacitesRaciales( "Demi-Elfe standard", 20, ensembleRacial[0] ) );


const vector< Prerequis > DemiElfe::Limites = list_of
  (Prerequis(1, 6, 18))
  (Prerequis(2, 6, 18))
  (Prerequis(3, 6, 18));

/**
 * Constructeur simplifié, qui remplit simplement le conteneur des capacités.
 * Il est utilisé lors de la lecture d'un fichier XML.
 *
 * @param[in] cap conteneur des capacité
 */
DemiElfe::DemiElfe(const vector<unsigned>& cap)
  : Race( "Demi-Elfe" )
{
  CapacitesRaciales    = Liste;
  NombreTotalCapacites = taille;
  EnsemblesRaciaux     = Ensembles;
  NombreTotalEnsembles = nbrEnsembles;
  NombreMaxCapacites   = nbrCapacites;
  PrerequisRaciaux     = Limites;

  Capacites.assign( cap . begin(), cap . end() );
}

/**
 * Constructeur usuel, qui permet de créer un Demi-Elfe en sélectionnant
 * ses capacités.
 *
 * @param PP[in,out] nombre de pp, passé en argument afin de pouvoir
 * récupéré les pp non dépensé
 */
DemiElfe::DemiElfe(unsigned& PP)
  : Race( "Demi-Elfe" )
{
  NombrePPsAlloues = ppAlloues;

  CapacitesRaciales    = Liste;
  NombreTotalCapacites = taille;
  EnsemblesRaciaux     = Ensembles;
  NombreTotalEnsembles = nbrEnsembles;
  NombreMaxCapacites   = nbrCapacites;
  PrerequisRaciaux     = Limites;

  blank() << setfill('*') << setw(56) << '*' << endmsg;
  blank() << "Création d'un demi-elfe" << endmsg << endmsg;
  
  PP = 25;

  construitRace( PP );
  
  blank() << endmsg << setfill('*') << setw(56) << '*' << endmsg;
}

DemiElfe::DemiElfe()
  : Race("Demi-Elfe")
{
  NombrePPsAlloues = ppAlloues;

  CapacitesRaciales    = Liste;
  NombreTotalCapacites = taille;
  EnsemblesRaciaux     = Ensembles;
  NombreTotalEnsembles = nbrEnsembles;
  NombreMaxCapacites   = nbrCapacites;
  PrerequisRaciaux     = Limites;
}

/**
 * Constructeur de "copie", qui permet de créer une instance à partir
 * de MetaClasse.
 *
 * @param[in] ptr pointeur sur l'instance à copier.
 */
DemiElfe::DemiElfe(Race* ptr)
  : Race( *ptr )
{
  NombrePPsAlloues = ppAlloues;
}

/**
 * Destructeur, ne fait rien de spécial.
 */
DemiElfe::~DemiElfe()
{}
